#include "lex-tools.h"
//necessary
#include "parser.h"

void printLexicalToken(FILE* f,int token){
	switch (token){

	case TOKEN_REQUIRE: {
		fprintf(f,"TOKEN_REQUIRE");break;
	}
	case TOKEN_PUBLIC: {
		fprintf(f,"TOKEN_PUBLIC");break;
	}

	case TOKEN_PACKAGE: {
		fprintf(f,"TOKEN_PACKAGE");break;
	}

	case TOKEN_ID: {
		fprintf(f,"TOKEN_ID");break;
	}

	case TOKEN_CLASS: {
		fprintf(f,"TOKEN_CLASS");break;
	}

	case TOKEN_STATIC: {
		fprintf(f,"TOKEN_STATIC");break;
	}

	case TOKEN_ABSTRACT: {
		fprintf(f,"TOKEN_ABSTRACT");break;
	}

	case TOKEN_EXTENDS: {
		fprintf(f,"TOKEN_EXTENDS");break;
	}

	case TOKEN_READABLE: {
		fprintf(f,"TOKEN_READABLE");break;
	}

	case TOKEN_BY: {
		fprintf(f,"TOKEN_BY");break;
	}

	case TOKEN_WRITEABLE: {
		fprintf(f,"TOKEN_WRITEABLE");break;
	}

	case TOKEN_ALL: {
		fprintf(f,"TOKEN_ALL");break;
	}

	case TOKEN_ONLYME: {
		fprintf(f,"TOKEN_ONLYME");break;
	}

	case TOKEN_CHILDREN: {
		fprintf(f,"TOKEN_CHILDREN");break;
	}

	case TOKEN_MEMBER: {
		fprintf(f,"TOKEN_MEMBER");break;
	}

	case TOKEN_OF: {
		fprintf(f,"TOKEN_OF");break;
	}

	case TOKEN_THIS: {
		fprintf(f,"TOKEN_THIS");break;
	}

	case TOKEN_ARRAY: {
		fprintf(f,"TOKEN_ARRAY");break;
	}

	case TOKEN_MINUS_D: {
		fprintf(f,"TOKEN_MINUS_D");break;
	}

	case TOKEN_REFERENCE: {
		fprintf(f,"TOKEN_REFERENCE");break;
	}

	case TOKEN_VALUE: {
		fprintf(f,"TOKEN_VALUE");break;
	}

	case TOKEN_INT: {
		fprintf(f,"TOKEN_INT");break;
	}

	case TOKEN_STRING: {
		fprintf(f,"TOKEN_STRING");break;
	}

	case TOKEN_BOOL: {
		fprintf(f,"TOKEN_BOOL");break;
	}

	case TOKEN_CHAR: {
		fprintf(f,"TOKEN_CHAR");break;
	}

	case TOKEN_CONST: {
		fprintf(f,"TOKEN_CONST");break;
	}

	case TOKEN_FUNCTION: {
		fprintf(f,"TOKEN_FUNCTION");break;
	}

	case TOKEN_VOID: {
		fprintf(f,"TOKEN_VOID");break;
	}

	case TOKEN_REAL: {
		fprintf(f,"TOKEN_REAL");break;
	}

	case TOKEN_COPY: {
		fprintf(f,"TOKEN_COPY");break;
	}

	case TOKEN_WHILE: {
		fprintf(f,"TOKEN_WHILE");break;
	}

	case TOKEN_DO: {
		fprintf(f,"TOKEN_DO");break;
	}

	case TOKEN_FOR: {
		fprintf(f,"TOKEN_FOR");break;
	}

	case TOKEN_TO: {
		fprintf(f,"TOKEN_TO");break;
	}

	case TOKEN_IF: {
		fprintf(f,"TOKEN_IF");break;
	}

	case TOKEN_THEN: {
		fprintf(f,"TOKEN_THEN");break;
	}

	case TOKEN_ELSIF: {
		fprintf(f,"TOKEN_ELSIF");break;
	}

	case TOKEN_ELSE: {
		fprintf(f,"TOKEN_ELSE");break;
	}

	case TOKEN_SWITCH: {
		fprintf(f,"TOKEN_SWITCH");break;
	}

	case TOKEN_CASE: {
		fprintf(f,"TOKEN_CASE");break;
	}

	case TOKEN_DEFAULT: {
		fprintf(f,"TOKEN_DEFAULT");break;
	}

	case TOKEN_CONTINUE: {
		fprintf(f,"TOKEN_CONTINUE");break;
	}

	case TOKEN_BREAK: {
		fprintf(f,"TOKEN_BREAK");break;
	}

	case TOKEN_RETURN: {
		fprintf(f,"TOKEN_RETURN");break;
	}

	case TOKEN_NEW: {
		fprintf(f,"TOKEN_NEW");break;
	}


	case TOKEN_ERROR: {
		fprintf(f,"TOKEN_ERROR");break;
	}


	case TOKEN_INTCONST: {
		fprintf(f,"TOKEN_INTCONST");break;
	}

	case TOKEN_STRINGCONST: {
		fprintf(f,"TOKEN_STRINGCONST");break;
	}

	case TOKEN_BOOLCONST: {
		fprintf(f,"TOKEN_BOOLCONST");break;
	}

	case TOKEN_FLOATCONST: {
		fprintf(f,"TOKEN_FLOATCONST");break;
	}

	case TOKEN_CHARCONST: {
		fprintf(f,"TOKEN_CHARCONST");break;
	}

	case TOKEN_LEQ: {
		fprintf(f,"TOKEN_LEQ");break;
	}

	case TOKEN_GEQ: {
		fprintf(f,"TOKEN_GEQ");break;
	}

	case TOKEN_EQ: {
		fprintf(f,"TOKEN_EQ");break;
	}

	case TOKEN_NE: {
		fprintf(f,"TOKEN_NE");break;
	}

	case TOKEN_AND: {
		fprintf(f,"TOKEN_AND");break;
	}

	case TOKEN_OR: {
		fprintf(f,"TOKEN_OR");break;
	}
	}
}
